﻿using System;
using System.Collections.Generic;
using System.Text;

namespace Microsoft.Xna.Framework.Graphics
{
    /// <summary>
    /// Defines color blending factors.
    /// </summary>
    public enum Blend
    {
		/// <summary>
		/// Each component of the color is multiplied by (1, 1, 1, 1).
		/// </summary>
		One,
		/// <summary>
		/// Each component of the color is multiplied by (0, 0, 0, 0).
		/// </summary>
        Zero,
		/// <summary>
		/// Each component of the color is multiplied by the source color. This can be represented as (Rs, Gs, Bs, As), where R, G, B, and A respectively stand for the red, green, blue, and alpha source values.
		/// </summary>
        SourceColor,
		/// <summary>
		/// Each component of the color is multiplied by the inverse of the source color. This can be represented as (1 − Rs, 1 − Gs, 1 − Bs, 1 − As) where R, G, B, and A respectively stand for the red, green, blue, and alpha destination values.
		/// </summary>
        InverseSourceColor,
		/// <summary>
		/// Each component of the color is multiplied by the alpha value of the source. This can be represented as (As, As, As, As), where As is the alpha source value.
		/// </summary>
        SourceAlpha,
		/// <summary>
		/// Each component of the color is multiplied by the inverse of the alpha value of the source. This can be represented as (1 − As, 1 − As, 1 − As, 1 − As), where As is the alpha destination value.
		/// </summary>
        InverseSourceAlpha,
		/// <summary>
		/// Each component color is multiplied by the destination color. This can be represented as (Rd, Gd, Bd, Ad), where R, G, B, and A respectively stand for red, green, blue, and alpha destination values.
		/// </summary>
		DestinationColor,
		/// <summary>
		/// Each component of the color is multiplied by the inverse of the destination color. This can be represented as (1 − Rd, 1 − Gd, 1 − Bd, 1 − Ad), where Rd, Gd, Bd, and Ad respectively stand for the red, green, blue, and alpha destination values.
		/// </summary>
		InverseDestinationColor,
		/// <summary>
		/// Each component of the color is multiplied by the alpha value of the destination. This can be represented as (Ad, Ad, Ad, Ad), where Ad is the destination alpha value.
		/// </summary>
        DestinationAlpha,
		/// <summary>
		/// Each component of the color is multiplied by the inverse of the alpha value of the destination. This can be represented as (1 − Ad, 1 − Ad, 1 − Ad, 1 − Ad), where Ad is the alpha destination value.
		/// </summary>
        InverseDestinationAlpha,
		/// <summary>
		/// Each component of the color is multiplied by a constant set in BlendFactor.
		/// </summary>
		BlendFactor,
		/// <summary>
		/// Each component of the color is multiplied by the inverse of a constant set in BlendFactor.
		/// </summary>
		InverseBlendFactor,
		/// <summary>
		/// Each component of the color is multiplied by either the alpha of the source color, or the inverse of the alpha of the source color, whichever is greater. This can be represented as (f, f, f, 1), where f = min(A, 1 − Ad).
		/// </summary>
        SourceAlphaSaturation,
    }

    /// <summary>
    /// Defines how to combine a source color with the destination color already on the render target for color blending.
    /// </summary>
    public enum BlendFunction
    {
		/// <summary>
		/// The result is the destination added to the source. Result = (Source Color * Source Blend) + (Destination Color * Destination Blend)
		/// </summary>
        Add,
		/// <summary>
		/// The result is the destination subtracted from the source. Result = (Source Color * Source Blend) − (Destination Color * Destination Blend)
		/// </summary>
        Subtract,
		/// <summary>
		/// The result is the source subtracted from the destination. Result = (Destination Color * Destination Blend) − (Source Color * Source Blend)
		/// </summary>
        ReverseSubtract,
		/// <summary>
		/// The result is the minimum of the source and destination. Result = min((Source Color * Source Blend), (Destination Color * Destination Blend))
		/// </summary>
        Min,
		/// <summary>
		/// The result is the maximum of the source and destination. Result = max((Source Color * Source Blend), (Destination Color * Destination Blend))
		/// </summary>
        Max,
    }

	/// <summary>
	/// Specifies special usage of the buffer contents.
	/// </summary>
	[Flags]
	public enum BufferUsage
	{
		/// <summary>
		/// None
		/// </summary>
		None,
		/// <summary>
		/// Indicates that the application only writes to the vertex buffer. If specified, the driver chooses the best memory location for efficient writing and rendering. Attempts to read from a write-only vertex buffer fail.
		/// </summary>
		WriteOnly
	}

	/// <summary>
	/// Specifies the buffer to use when calling Clear.
	/// </summary>
	[Flags]
	public enum ClearOptions
	{
		/// <summary>
		/// A render target.
		/// </summary>
		Target = 1,
		/// <summary>
		/// A depth buffer.
		/// </summary>
		DepthBuffer = 2,
		/// <summary>
		/// A stencil buffer.
		/// </summary>
		Stencil = 4,
	}

	/// <summary>
	/// Defines the color channels that can be chosen for a per-channel write to a render target color buffer.
	/// </summary>
	[Flags]
	public enum ColorWriteChannels
	{
		/// <summary>
		/// No channel selected.
		/// </summary>
		None = 0,
		/// <summary>
		/// Red channel of a buffer.
		/// </summary>
		Red = 1,
		/// <summary>
		/// Green channel of a buffer.
		/// </summary>
		Green = 2,
		/// <summary>
		/// Blue channel of a buffer.
		/// </summary>
		Blue = 4,
		/// <summary>
		/// Alpha channel of a buffer.
		/// </summary>
		Alpha = 8,
		/// <summary>
		/// All buffer channels.
		/// </summary>
		All = 15,
	}

    /// <summary>
    /// Defines comparison functions that can be chosen for alpha, stencil, or depth-buffer tests.
    /// </summary>
    public enum CompareFunction
    {
		/// <summary>
		/// Always pass the test.
		/// </summary>
		Always,
		/// <summary>
		/// Always fail the test.
		/// </summary>
        Never,
		/// <summary>
		/// Accept the new pixel if its value is less than the value of the current pixel.
		/// </summary>
        Less,
		/// <summary>
		/// Accept the new pixel if its value is less than or equal to the value of the current pixel.
		/// </summary>
		LessEqual,
		/// <summary>
		/// Accept the new pixel if its value is equal to the value of the current pixel.
		/// </summary>
        Equal,
		/// <summary>
		/// Accept the new pixel if its value is greater than or equal to the value of the current pixel.
		/// </summary>
		GreaterEqual,
		/// <summary>
		/// Accept the new pixel if its value is greater than the value of the current pixel.
		/// </summary>
        Greater,
		/// <summary>
		/// Accept the new pixel if its value does not equal the value of the current pixel.
		/// </summary>
        NotEqual,
    }

	/// <summary>
	/// Defines the faces of a cube map in the TextureCube class type.
	/// </summary>
	public enum CubeMapFace
	{
		/// <summary>
		/// Positive x-face of the cube map.
		/// </summary>
		PositiveX,
		/// <summary>
		/// Negative x-face of the cube map.
		/// </summary>
		NegativeX,
		/// <summary>
		/// Positive y-face of the cube map.
		/// </summary>
		PositiveY,
		/// <summary>
		/// Negative y-face of the cube map.
		/// </summary>
		NegativeY,
		/// <summary>
		/// Positive z-face of the cube map.
		/// </summary>
		PositiveZ,
		/// <summary>
		/// Negative z-face of the cube map.
		/// </summary>
		NegativeZ,
	}

    /// <summary>
    /// Defines winding orders that may be used to identify back faces for culling.
    /// </summary>
    public enum CullMode
    {
		/// <summary>
		/// Do not cull back faces.
		/// </summary>
        None,
		/// <summary>
		/// Cull back faces with clockwise vertices.
		/// </summary>
        CullClockwiseFace,
		/// <summary>
		/// Cull back faces with counterclockwise vertices.
		/// </summary>
        CullCounterClockwiseFace
    }

	/// <summary>
	/// Defines the format of data in a depth buffer.
	/// </summary>
	public enum DepthFormat
	{
		/// <summary>
		/// Do not create a depth buffer.
		/// </summary>
		None,
		/// <summary>
		/// A buffer that contains 16-bits of depth data.
		/// </summary>
		Depth16,
		/// <summary>
		/// A buffer that contains 24-bits of depth data.
		/// </summary>
		Depth24,
		/// <summary>
		/// A 32 bit buffer that contains 24 bits of depth data and 8 bits of stencil data.
		/// </summary>
		Depth24Stencil8,
	}

	/// <summary>
	/// Defines classes that can be used for effect parameters or shader constants.
	/// </summary>
	public enum EffectParameterClass
	{
		/// <summary>
		/// Constant is a scalar.
		/// </summary>
		Scalar,
		/// <summary>
		/// Constant is a vector.
		/// </summary>
		Vector,
		/// <summary>
		/// Constant is a matrix.
		/// </summary>
		Matrix,
		/// <summary>
		/// Constant is either a texture, a shader, or a string.
		/// </summary>
		Object,
		/// <summary>
		/// Constant is a structure.
		/// </summary>
		Struct
	}

	/// <summary>
	/// Defines types that can be used for effect parameters or shader constants.
	/// </summary>
	public enum EffectParameterType
	{
		/// <summary>
		/// Parameter is a void pointer.
		/// </summary>
		Void,
		/// <summary>
		/// Parameter is a Boolean. Any nonzero value passed in will be mapped to 1 (TRUE) before being written into the constant table; otherwise, the value will be set to 0 in the constant table.
		/// </summary>
		Bool,
		/// <summary>
		/// Parameter is an integer. Any floating-point values passed in will be rounded off (to zero decimal places) before being written into the constant table.
		/// </summary>
		Int32,
		/// <summary>
		/// Parameter is a floating-point number.
		/// </summary>
		Single,
		/// <summary>
		/// Parameter is a string.
		/// </summary>
		String,
		/// <summary>
		/// Parameter is a texture.
		/// </summary>
		Texture,
		/// <summary>
		/// Parameter is a 1D texture.
		/// </summary>
		Texture1D,
		/// <summary>
		/// Parameter is a 2D texture.
		/// </summary>
		Texture2D,
		/// <summary>
		/// Parameter is a 3D texture.
		/// </summary>
		Texture3D,
		/// <summary>
		/// Parameter is a cube texture.
		/// </summary>
		TextureCube
	}

    /// <summary>
    /// Describes options for filling the vertices and lines that define a primitive.
    /// </summary>
    public enum FillMode
    {
		/// <summary>
		/// Draw solid faces for each primitive.
		/// </summary>
		Solid,
		/// <summary>
		/// Draw lines connecting the vertices that define a primitive face.
		/// </summary>
        WireFrame,
    }

	/// <summary>
	/// Describes the status of the device.
	/// </summary>
	public enum GraphicsDeviceStatus
	{
		/// <summary>
		/// The device is normal.
		/// </summary>
		Normal,
		/// <summary>
		/// The device has been lost.
		/// </summary>
		Lost,
		/// <summary>
		/// The device has not been reset.
		/// </summary>
		NotReset,
	}

	/// <summary>
	/// Identifies the set of supported devices for the game based on device capabilities.
	/// </summary>
	public enum GraphicsProfile
	{
		/// <summary>
		/// Use a limited set of graphic features and capabilities, allowing the game to support the widest variety of devices, including all Windows-based computers and Windows Phone.
		/// </summary>
		Reach,
		/// <summary>
		/// Use the largest available set of graphic features and capabilities to target devices, such as an Xbox 360 console and a Windows-based computer, that have more enhanced graphic capabilities.
		/// </summary>
		HiDef
	}

    /// <summary>
    /// Defines constants that describe supported texture-addressing modes.
    /// </summary>
    public enum TextureAddressMode
    {
        Border = 4,
        Clamp = 3,
        Mirror = 2,
        MirrorOnce = 5,
        Wrap = 1
    }

	/// <summary>
	/// Defines sprite sort-rendering options.
	/// </summary>
	public enum SpriteSortMode
	{
		/// <summary>
		/// Sprites are not drawn until End is called. End will apply graphics device settings and draw all the sprites in one batch, in the same order calls to Draw were received. This mode allows Draw calls to two or more instances of SpriteBatch without introducing conflicting graphics device settings. SpriteBatch defaults to Deferred mode.
		/// </summary>
		Deferred,
		/// <summary>
		/// Begin will apply new graphics device settings, and sprites will be drawn within each Draw call. In Immediate mode there can only be one active SpriteBatch instance without introducing conflicting device settings.
		/// </summary>
		Immediate,
		/// <summary>
		/// Same as Deferred mode, except sprites are sorted by texture prior to drawing. This can improve performance when drawing non-overlapping sprites of uniform depth.
		/// </summary>
		Texture,
		/// <summary>
		/// Same as Deferred mode, except sprites are sorted by depth in back-to-front order prior to drawing. This procedure is recommended when drawing transparent sprites of varying depths.
		/// </summary>
		BackToFront,
		/// <summary>
		/// Same as Deferred mode, except sprites are sorted by depth in front-to-back order prior to drawing. This procedure is recommended when drawing opaque sprites of varying depths.
		/// </summary>
		FrontToBack
	}

	/// <summary>
	/// Defines stencil buffer operations.
	/// </summary>
	public enum StencilOperation
	{
		Keep = 1,
		Zero = 2,
		Replace = 3,
		IncrementSaturation = 4,
		DecrementSaturation = 5,
		Invert = 6,
		Increment = 7,
		Decrement = 8,
	}

    /// <summary>
    /// Defines various types of surface formats.
    /// </summary>
    public enum SurfaceFormat
    {
		/// <summary>
		/// (Unsigned format) 32-bit ARGB pixel format with alpha, using 8 bits per channel.
		/// </summary>
		Color = 0,
		/// <summary>
		/// (Unsigned format) 16-bit BGR pixel format with 5 bits for blue, 6 bits for green, and 5 bits for red.
		/// </summary>
		Bgr565,
		/// <summary>
		/// (Unsigned format) 16-bit BGRA pixel format where 5 bits are reserved for each color and 1 bit is reserved for alpha.
		/// </summary>
		Bgra5551,
		/// <summary>
		/// (Unsigned format) 16-bit BGRA pixel format with 4 bits for each channel.
		/// </summary>
		Bgra4444,
		/// <summary>
		/// DXT1 compression texture format. The runtime will not allow an application to create a surface using a DXTn format unless the surface dimensions are multiples of 4. This applies to offscreen-plain surfaces, render targets, 2D textures, cube textures, and volume textures.
		/// </summary>
		Dxt1,
		/// <summary>
		/// DXT3 compression texture format. The runtime will not allow an application to create a surface using a DXTn format unless the surface dimensions are multiples of 4. This applies to offscreen-plain surfaces, render targets, 2D textures, cube textures, and volume textures
		/// </summary>
		Dxt3,
		/// <summary>
		/// DXT5 compression texture format. The runtime will not allow an application to create a surface using a DXTn format unless the surface dimensions are multiples of 4. This applies to offscreen-plain surfaces, render targets, 2D textures, cube textures, and volume textures.
		/// </summary>
		Dxt5,
		/// <summary>
		/// (Signed format) 16-bit bump-map format using 8 bits each for u and v data.
		/// </summary>
		NormalizedByte2,
		/// <summary>
		/// (Signed format) 32-bit bump-map format using 8 bits for each channel.
		/// </summary>
		NormalizedByte4,
		/// <summary>
		/// (Unsigned format) 32-bit RGBA pixel format using 10 bits for each color and 2 bits for alpha.
		/// </summary>
		Rgba1010102,
		/// <summary>
		/// (Unsigned format) 32-bit pixel format using 16 bits each for red and green.
		/// </summary>
		Rg32,
		/// <summary>
		/// (Unsigned format) 64-bit RGBA pixel format using 16 bits for each component.
		/// </summary>
		Rgba64,
		/// <summary>
		/// (Unsigned format) 8-bit alpha only.
		/// </summary>
		Alpha8,
		/// <summary>
		/// (IEEE format) 32-bit float format using 32 bits for the red channel.
		/// </summary>
		Single,
		/// <summary>
		/// (IEEE format) 64-bit float format using 32 bits for the red channel and 32 bits for the green channel.
		/// </summary>
		Vector2,
		/// <summary>
		/// (IEEE format) 128-bit float format using 32 bits for each channel (alpha, blue, green, red).
		/// </summary>
		Vector4,
		/// <summary>
		/// (Floating-point format) 16-bit float format using 16 bits for the red channel.
		/// </summary>
		HalfSingle,
		/// <summary>
		/// (Floating-point format) 32-bit float format using 16 bits for the red channel and 16 bits for the green channel.
		/// </summary>
		HalfVector2,
		/// <summary>
		/// (Floating-point format) 64-bit float format using 16 bits for each channel (alpha, blue, green, red).
		/// </summary>
		HalfVector4,
		/// <summary>
		/// (Floating-point format) for high dynamic range data.
		/// </summary>
		HdrBlendable
    }

    /// <summary>
    /// Defines the levels of full-scene multisampling that the game machine can apply.
    /// </summary>
    public enum MultiSampleType
    {
        None = 0,
        NonMaskable = 1,
        TwoSamples = 2,
        ThreeSamples = 3,
        FourSamples = 4,
        FiveSamples = 5,
        SixSamples = 6,
        SevenSamples = 7,
        EightSamples = 8,
        NineSamples = 9,
        TenSamples = 10,
        ElevenSamples = 11,
        TwelveSamples = 12,
        ThirteenSamples = 13,
        FourteenSamples = 14,
        FifteenSamples = 15,
        SixteenSamples = 16,
    }

    /// <summary>
    /// Defines flags that describe the relationship between the adapter refresh rate and the rate at which Present operations are completed.
    /// </summary>
    public enum PresentInterval
    {
		/// <summary>
		/// Equivalent to setting One.
		/// </summary>
		Default,
		/// <summary>
		/// The driver waits for the vertical retrace period (the runtime will beam trace to prevent tearing). Present operations are not affected more frequently than the screen refresh rate; the runtime completes one Present operation per adapter refresh period, at most. This option is always available for both windowed and full-screen swap chains.
		/// </summary>
		One,
		/// <summary>
		/// The driver waits for the vertical retrace period. Present operations are not affected more frequently than every second screen refresh.
		/// </summary>
		Two,
		/// <summary>
		/// The runtime updates the window client area immediately, and might do so more than once during the adapter refresh period. Present operations might be affected immediately. This option is always available for both windowed and full-screen swap chains.
		/// </summary>
		Immediate
    }

    /// <summary>
    /// Defines the data type of a shader register.
    /// </summary>
    public enum ShaderRegisterSet
    {
        Boolean = 0,
        Int4 = 1,
        Float4 = 2,
        Sampler = 3
    }

    /// <summary>
    /// Defines options for saving the graphics device state before and after an effect technique is applied.
    /// </summary>
    public enum SaveStateMode
    {
        None = 0,
        SaveState = 1
    }

    /// <summary>
    /// Defines sprite mirroring options.
    /// </summary>
    [Flags]
    public enum SpriteEffects
    {
        None = 0,
        FlipHorizontally = 1,
        FlipVertically = 256
    }

    /// <summary>
    /// The following flags are used to specify sprite blending rendering options to the flags parameter in Begin:
    /// </summary>
    public enum SpriteBlendMode
    {
        None = 0,
        AlphaBlend = 1,
        Additive = 2
    }

    [Flags]
    public enum ResourceUsage
    {
        Tiled = -2147483648,
        None = 0,
        ResolveTarget = 1,
        WriteOnly = 8,
        SoftwareProcessing = 16,
        DoNotClip = 32,
        Points = 64,
        Dynamic = 512,
        AutoGenerateMipMap = 1024,
        Linear = 1073741824,
    }

    /// <summary>
    /// Defines options for querying device resource formats.
    /// </summary>
    [Flags]
    public enum QueryUsages
    {
        None = 0,
        SrgbRead = 65536,
        Filter = 131072,
        SrgbWrite = 262144,
        PostPixelShaderBlending = 524288,
        VertexTexture = 1048576,
        WrapAndMip = 2097152,
    }

    /// <summary>
    /// Defines resource types.
    /// </summary>
    public enum ResourceType
    {
        DepthStencilBuffer = 1,
        Texture3DVolume = 2,
        Texture2D = 3,
        Texture3D = 4,
        TextureCube = 5,
        VertexBuffer = 6,
        IndexBuffer = 7,
        RenderTarget = 8
    }

    /// <summary>
    /// Defines how data in a vertex stream is interpreted during a draw call.
    /// </summary>
    public enum PrimitiveType
    {
        PointList = 1,
        LineList = 2,
        LineStrip = 3,
        TriangleList = 4,
        TriangleStrip = 5,
        TriangleFan = 6,
    }

    /// <summary>
    /// Defines vertex and pixel shader versions.
    /// </summary>
    public enum ShaderProfile
    {
        PS_1_1 = 0,
        PS_1_2 = 1,
        PS_1_3 = 2,
        PS_1_4 = 3,
        PS_2_0 = 4,
        PS_2_A = 5,
        PS_2_B = 6,
        PS_2_SW = 7,
        PS_3_0 = 8,
        XPS_3_0 = 9,
        VS_1_1 = 10,
        VS_2_0 = 11,
        VS_2_A = 12,
        VS_2_SW = 13,
        VS_3_0 = 14,
        XVS_3_0 = 15,
        Unknown = 16,
    }

    /// <summary>
    /// Defines the size of an element of an index buffer.
    /// </summary>
    public enum IndexElementSize
    {
        SixteenBits = 0,
        ThirtyTwoBits = 1,
    }

    public enum ResourceManagementMode
    {
        Manual = 0,
        Automatic = 1,
    }

    /// <summary>
    /// Describes whether existing buffer data will be overwritten or discarded during a SetData operation.
    /// </summary>
    [Flags]
    public enum SetDataOptions
    {
        None = 0,
        NoOverwrite = 4096,
        Discard = 8192,
    }

    /// <summary>
    /// Defines supported image file formats that may be used for textures.
    /// </summary>
    internal enum ImageFileFormat
    {
        Bmp = 0,
        Jpg = 1,
        Tga = 2,
        Png = 3,
        Dds = 4,
        Ppm = 5,
        Dib = 6,
        Hdr = 7,
        Pfm = 8,
    }

	/// <summary>
	/// Defines how a texture will be filtered as it is minified for each mipmap level.
	/// </summary>
	public enum TextureFilter
	{
		/// <summary>
		/// Use linear filtering.
		/// </summary>
		Linear,
		/// <summary>
		/// Use point filtering.
		/// </summary>
		Point,
		/// <summary>
		/// Use anisotropic filtering.
		/// </summary>
		Anisotropic,
		/// <summary>
		/// Use linear filtering to shrink or expand, and point filtering between mipmap levels (mip).
		/// </summary>
		LinearMipPoint,
		/// <summary>
		/// Use point filtering to shrink (minify) or expand (magnify), and linear filtering between mipmap levels.
		/// </summary>
		PointMipLinear,
		/// <summary>
		/// Use linear filtering to shrink, point filtering to expand, and linear filtering between mipmap levels.
		/// </summary>
		MinLinearMagPointMipLinear,
		/// <summary>
		/// Use linear filtering to shrink, point filtering to expand, and point filtering between mipmap levels.
		/// </summary>
		MinLinearMagPointMipPoint,
		/// <summary>
		/// Use point filtering to shrink, linear filtering to expand, and linear filtering between mipmap levels.
		/// </summary>
		MinPointMagLinearMipLinear,
		/// <summary>
		/// Use point filtering to shrink, linear filtering to expand, and point filtering between mipmap levels.
		/// </summary>
		MinPointMagLinearMipPoint
	}

	/// <summary>
	/// Defines vertex element formats.
	/// </summary>
	public enum VertexElementFormat
	{
		/// <summary>
		/// Single-component, 32-bit floating-point, expanded to (float, 0, 0, 1).
		/// </summary>
		Single,
		/// <summary>
		/// Two-component, 32-bit floating-point, expanded to (float, Float32 value, 0, 1).
		/// </summary>
		Vector2,
		/// <summary>
		/// Three-component, 32-bit floating point, expanded to (float, float, float, 1).
		/// </summary>
		Vector3,
		/// <summary>
		/// Four-component, 32-bit floating point, expanded to (float, float, float, float).
		/// </summary>
		Vector4,
		/// <summary>
		/// Four-component, packed, unsigned byte, mapped to 0 to 1 range. Input is in Int32 format (ARGB) expanded to (R, G, B, A).
		/// </summary>
		Color,
		/// <summary>
		/// Four-component, unsigned byte.
		/// </summary>
		Byte4,
		/// <summary>
		/// Two-component, signed short expanded to (value, value, 0, 1).
		/// </summary>
		Short2,
		/// <summary>
		/// Four-component, signed short expanded to (value, value, value, value).
		/// </summary>
		Short4,
		/// <summary>
		/// Normalized, two-component, signed short, expanded to (first short/32767.0, second short/32767.0, 0, 1). This type is valid for vertex shader version 2.0 or higher.
		/// </summary>
		NormalizedShort2,
		/// <summary>
		/// Normalized, four-component, signed short, expanded to (first short/32767.0, second short/32767.0, third short/32767.0, fourth short/32767.0). This type is valid for vertex shader version 2.0 or higher.
		/// </summary>
		NormalizedShort4,
		/// <summary>
		/// Two-component, 16-bit floating point expanded to (value, value, value, value). This type is valid for vertex shader version 2.0 or higher.
		/// </summary>
		HalfVector2,
		/// <summary>
		/// Four-component, 16-bit floating-point expanded to (value, value, value, value). This type is valid for vertex shader version 2.0 or higher.
		/// </summary>
		HalfVector4,
	}

	/// <summary>
	/// Defines usage for vertex elements.
	/// </summary>
	public enum VertexElementUsage
	{
		/// <summary>
		/// Position data. (Position with UsageIndex = 0 ) specifies the nontransformed position in fixed-function vertex processing and the N-patch tessellator. (Position with UsageIndex = 1) specifies the nontransformed position in the fixed-function vertex shader for skinning.
		/// </summary>
		Position,
		/// <summary>
		/// Vertex data contains diffuse or specular color. (Color with UsageIndex = 0) specifies the diffuse color in the fixed-function vertex shader and in pixel shaders prior to ps_3_0. (Color with UsageIndex = 1) specifies the specular color in the fixed-function vertex shader and in pixel shaders prior to ps_3_0.
		/// </summary>
		Color,
		/// <summary>
		/// Texture coordinate data. (TextureCoordinate, n) specifies texture coordinates in fixed-function vertex processing and in pixel shaders prior to ps_3_0. These coordinates can be used to pass user-defined data.
		/// </summary>
		TextureCoordinate,
		/// <summary>
		/// Vertex normal data. (Normal with UsageIndex = 0) specifies vertex normals for fixed-function vertex processing and the N-patch tessellator. (Normal with UsageIndex = 1) specifies vertex normals for fixed-function vertex processing for skinning.
		/// </summary>
		Normal,
		/// <summary>
		/// Vertex binormal data.
		/// </summary>
		Binormal,
		/// <summary>
		/// Vertex tangent data.
		/// </summary>
		Tangent,
		/// <summary>
		/// Blending indices data. (BlendIndices with UsageIndex = 0) specifies matrix indices for fixed-function vertex processing using indexed paletted skinning.
		/// </summary>
		BlendIndices,
		/// <summary>
		/// Blending weight data. (BlendWeight with UsageIndex = 0) specifies the blend weights in fixed-function vertex processing.
		/// </summary>
		BlendWeight,
		/// <summary>
		/// Vertex data contains depth data.
		/// </summary>
		Depth,
		/// <summary>
		/// Vertex data contains fog data. (Fog with UsageIndex = 0) specifies a fog blend value to use after pixel shading is finished. This flag applies to pixel shaders prior to version ps_3_0.
		/// </summary>
		Fog,
		/// <summary>
		/// Point size data. (PointSize with UsageIndex = 0) specifies the point-size attribute used by the setup engine of the rasterizer to expand a point into a quad for the point-sprite functionality.
		/// </summary>
		PointSize,
		/// <summary>
		/// Vertex data contains sampler data. (Sample with UsageIndex = 0) specifies the displacement value to look up.
		/// </summary>
		Sample,
		/// <summary>
		/// Single, positive floating-point value. (TessellateFactor with UsageIndex = 0) specifies a tessellation factor used in the tessellation unit to control the rate of tessellation.
		/// </summary>
		TessellateFactor
	}
}
